﻿using System;
using System.Data;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Windows.Forms;
using Microsoft.VisualBasic;
using System.Threading;
using NFe_Util_2G;


namespace Siav
{
    //[System.Runtime.InteropServices.GuidAttribute("8B76EE39-C061-487D-8353-6422FEA4B026")]
    public partial class frmEmiteNFe : Form
    {
        public frmEmiteNFe()
        {
            InitializeComponent();
        }
        //DEUS MARAVILHOSO
        
        public string CodigoPedido;
        
        NumberFormatInfo nfi = new CultureInfo("pt-br", false).NumberFormat;
        SiavEntities Entidades = new SiavEntities();
        DateTime DataEmissao = DateTime.Now;
        DateTime EntradaSaida = DateTime.Now;

        
        string HoraSaida = DateTime.Now.ToLongTimeString();

        //
        //
        //  Exemplo de geração de uma NF-e com as funcionalidades oferecidas pela DLL
        //
        //  A NF-e é formada por diversas grupos de tags e as grupos obrigatórios são:
        //
        //  NFe
        //    +-----infNFe
        //    |          +-----+--ide  (identificação da NF-e)
        //    |                |
        //    |                +--emit (identificação do emitente)
        //    |                |
        //    |                +--dest (identificação do destinatário)
        //    |                |
        //    |                +--det
        //    |                |    +-------+--prod (detalhe do produto)
        //    |                |            |
        //    |                |            +--imposto
        //    |                |                     +-------+--ICMS   (informações do ICMS)
        //    |                |                             |
        //    |                |                             +--PIS    (informações do PIS)
        //    |                |                             |
        //    |                |                             +--COFINS (informações do COFINS)
        //    |                +--det
        //    |                |    +-------+--prod (detalhe do produto)
        //    |                |            |
        //    |                |            +--imposto
        //    |                |                     +-------+--ICMS   (informações do ICMS)
        //    |                |                             |
        //    |                |                             +--PIS    (informações do PIS)
        //    |                |                             |
        //    |                |                             +--COFINS (informações do COFINS)
        //    |                +--det
        //    |                |    +-------+--prod (detalhe do produto)
        //    |                |            |
        //    |                |            +--imposto
        //    |                |                     +-------+--ICMS   (informações do ICMS)
        //    |                |                             |
        //    |                |                             +--PIS    (informações do PIS)
        //    |                |                             |
        //    |                |                             +--COFINS (informações do COFINS)
        //    |                |
        //    |                +--total (total da NF-e)
        //    |                |
        //    |                +--transp (Informações do Transporte)
        //    |                |
        //    |                +--infAdic (informações adicionais)
        //    |
        //    +-----Signature  (assinatura digital XML)
        //
        //  Como este demo tem efeitos meramente didático, vamos criar uma NF-e com os campos mínimos
        //  o usuário deverá informar os demais campos se necessário, a página 85 do Manual de integração tem diagrama simplificado da NF-e
        //
        //  IMPORTANTE: O desenvolvedor deve ter familiaridade com os nomes dos campos da NF-e, sendo altamente recomendada a correta
        //              compressão do leiuate da NF-e e das regras de preenchimento dos respectivos campos.
        //
        //  A NF-e é uma estrutra de árvore com o elemento raiz chamada NF-e que tem diversos "galhos/folhas"
        //  Para criar a NF-e com a DLL, o usuário deve começar a criar os itens das extrDim emidadas, ou seja os itens mais internos.
        //  Assim, uma boa ordem de criação dos grupos seria:
        //
        //  1. criar o grupo de informações do emitente (emit);
        //  2. criar o grupo de informações de identificação da NF-e (ide);
        //  3. criar o grupo de informações do destinatário (dest);
        //  4.1 criar o detalhe do produto (prod);
        //  4.2 criar o detalhe do ICMS (ICMS);
        //  4.3 criar o detalhe do PIS (PIS);
        //  4.4 criar o detalhe do COFINS (COFINS);
        //  4.5 criar o detalhe do imposto (imposto), consolidar ICMS, PIS e COFINS;
        //  4.6 criar o detalhe do item (det), consolidar prod e imposto;
        //  5. criar o grupo de Dim total da NF-e (total);
        //  6. criar o grupo de informações do transporte (transp);
        //  7. criar o grupo de informações adicionais (infAdic);
        //  8. criar o grupo de informações da NF-e (infNFe), consolidando ide, emit, dest, det, total e transp
        //  9. criar o grupo da NF-e
        //
        //
        //   DECLARAÇÃO DAS VARIÁVEIS
        //======Identificação do documento=======
        //
        string ide;
        int ide_cUF;
        int ide_cNF;
        string ide_natOp;
        int ide_indPag;
        int ide_mode;
        int ide_serie;
        int ide_nNF;
        DateTime ide_dEmi;
        DateTime ide_dSaiEnt;
        int ide_tpNF;
        string ide_cMunFG;
        int ide_tpImp;
        int ide_cDV;
        int ide_tpAmb;
        int ide_finNFe;
        int ide_tpEmis;
        int ide_procEmi;
        string ide_verProc;
        string ide_NFref;
        DateTime ide_dhCont;
        string ide_xJust, ide_hSaiEnt;
        //
        //======  Dados do  Dim emitente==========
        //
        string emi;
        string emi_CNPJ;
        string emi_CPF;
        string emi_xNome;
        string emi_xFant;
        string emi_xLgr;
        string emi_nro;
        string emi_xCpl;
        string emi_xBairro;
        string emi_cMun;
        string emi_xMun;
        string emi_UF;
        string emi_CEP;
        string emi_cPais;
        string emi_xPais;
        string emi_fone;
        string emi_IE;
        string emi_IEST;
        string emi_IM;
        string emi_CNAE;
        string emi_CRT;
        //
        //======  Dados do Dim destinatário==========
        //
        string dest;
        string dest_CNPJ;
        string dest_CPF;
        string dest_xNome;
        string dest_xFant;
        string dest_xLgr;
        string dest_nro;
        string dest_xCpl;
        string dest_xBairro;
        string dest_cMun;
        string dest_xMun;
        string dest_UF;
        string dest_CEP;
        string dest_cPais;
        string dest_xPais;
        string dest_fone;
        string dest_IE;
        string dest_IESUF;
        string dest_Email;
        //
        //====== Valor Dim total da NF-e ============
        //
        string total;
        string totICMS;
        double totICMS_vBC;
        double totICMS_vICMS;
        double totICMS_vBCST;
        double totICMS_vST;
        double totICMS_vProd;
        double totICMS_vFrete;
        double totICMS_vSeg;
        double totICMS_vDesc;
        double totICMS_vII;
        double totICMS_vIPI;
        double totICMS_vPIS;
        double totICMS_vCOFINS;
        double totICMS_vOutro;
        double totICMS_vNF;
        //
        //======  Dados do Transportador=========
        //
        string transp;
        string transpModFrete;
        //
        //======  Informações Adicionais==========
        //
        string infAdic;
        string infAdic_infAdiFisco;
        string infAdic_infCPL;
        //
        //======== Nota Fiscal ==================
        //
        string NFe;
        string ChaveNFe;
        string versao;
        string id;
        string retirada;
        string entrega;
        string compra;
        string exporta;
        string cobr;
        string detalhes;
        //
        //======== Detalhe do Produto ==================
        //
        string prod;
        string Prod_cProd;
        string Prod_cEAN;
        string Prod_xProd;
        string Prod_NCM;
        string Prod_ExTIPI;
        int Prod_genero;
        int Prod_CFOP;
        string Prod_uCOM;
        string Prod_qCom;
        string Prod_vUnCom;
        double Prod_vProd;
        string Prod_cEANTrib;
        string Prod_uTrib;
        string Prod_qTrib;
        string Prod_vUnTrib;
        double prod_Vdesc;
        double Prod_vFrete;
        double Prod_vOutro;
        double Prod_vSeguro;
        string Prod_DI;
        string Prod_DetEspecifico;
        string Prod_infAdProd;
        int Prod_indTot;
        string prod_detestpecifico;
        string Prod_XPed;
        int Prod__nItemPed;
        //
        //=========dados do ICMS===========
        //
        string icms;
        string icms_orig;
        string icms_CST;
        int icms_modBC;
        double icms_pRedBC;
        double icms_vBC;
        double icms_pICMS;
        double icms_vICMS;
        int icms_modBCST;
        double icms_pmVAST;
        double icms_pRedBCST;
        double icms_BCST;
        double icms_pICMSST;
        double icms_vICMSST;
        int icms_vmodbcst;
        double icms_vBCST;
        double vBCSTRet;
        double vICMSSRet;
        double vBCSTDest;
        double vICMSSTDest;
        int motDesICMS;
        double pBCOp;
        string UFST;
        double pCredSN;
        double vCredICMSSN;
        double ValordoICMSST;
        //
        //=========dados do PIS=============
        //
        string pis_CST;
        double pis_vBC;
        double pis_pPIS;
        double pis_vPIS;
        double pis_qBCProd;
        double pis_vAliqProd;
        //
        //========dados do COFINS============
        //
        string cofins_CST;
        double cofins_vBC;
        double cofins_pCOFINS;
        double cofins_vCOFINS;
        double cofins_qBCProd;
        double cofins_vAliqProd;
        double PIS_AliqProd;
        double cofins_AliqProd;
        double icms_vST;
        double prod_vSeg;
        string vCana;


        string TranspCPF;


        public decimal totalV;
        private int CodigoItem;
        public string nomeNota;
        public string TranspCNPJ;
//Cancelamento
        string ProcCancelNFE = "";
        string msgRetorno;
        string msgWSRetorno;
        int codRetorno;
        string msgResultado;
        string nroProtocoloCan;
        string dhProtcoloCan;

        private void CarregaPedidoParaBaixa(string pPedido)
        {
            try
            {
                if (pPedido != "-1")
                {
                    int CodigoPedido = int.Parse(pPedido);
                    var Pedido = Entidades.PedidoCabeca.FirstOrDefault(ped => ped.CodigoPedido.Equals(CodigoPedido));

                    lblNomeCliente.Text = Pedido.Clientes.RazaoSocial;
                    //lblTotalPedido.Text = Pedido.ValorTotal.Value.ToString("N", nfi);
                    lblValorParaCalculo.Text = Pedido.ValorTotal.ToString();
                    CarregaProdutosLista(pPedido);
                    CalculoDesconto(txtPorcentagemDesconto.Text, lblValorParaCalculo.Text);
                }
            }
            catch
            {
                MessageBox.Show("Pedido não encontrado", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
        public void CopiaProdutosTab(string pCodigo)
        {
            int CodigoPedido = int.Parse(pCodigo);
            var Registros = Entidades.NFe_Produtos.Where(pdi => pdi.nNFe == CodigoPedido).ToList();
            if (Registros.Count > 0)
            {
                foreach (NFe_Produtos ProdSe in Registros)
                {
                Entidades.DeleteObject(ProdSe);
                Entidades.SaveChanges();
                }
                
            }
            
            var Prods = (from p in Entidades.PedidoDetalhes
                         where p.item_ped_codigo.Equals(CodigoPedido)
                         select p).ToList();
            decimal totalV = 0;
            decimal preco = 0;
            decimal peso = 0;
            decimal totalP = 0;
            int i = 1;

            foreach (PedidoDetalhes Ped in Prods)
            {
                try
                {
                    SiavEntities Novo = new SiavEntities();
                    NFe_Produtos Produtos = new NFe_Produtos();
                    Produtos.prod_cProd = Validacoes.removeFormatacao(Validacoes.TirarAcento(Ped.Produtos.CodigoProduto));
                    Produtos.prod_xProd = Validacoes.TirarAcento(String.Format("{0} - {1} X {2}", Validacoes.TirarAcento(Ped.Produtos.NomeProduto), Ped.item_largura.Value, Ped.item_altura.Value));
                    Produtos.prod_NCM = "39";
                    Produtos.prod_CFOP = Ped.PedidoCabeca.CFOP;
                    Produtos.prod_uCOM = Ped.item_unidade;
                    Produtos.prod_qCOM = decimal.Parse(Ped.item_quantidade_final.Value.ToString("00.00"));
                    Produtos.prod_vUnCOM = 0;
                    decimal vValor = 0;
                    decimal pQuantidade = decimal.Parse(Ped.item_quantidade.Value.ToString("00.00"));
                    Produtos.prod_vProd = vValor * pQuantidade;
                    Produtos.prod_uTriv = Ped.item_unidade;
                    Produtos.prod_qTriv = Ped.item_quantidade_final.ToString();
                    Produtos.prod_vUnTrib = decimal.Parse(Ped.item_valor_kg.ToString());
                    Produtos.nNFe = Ped.item_ped_codigo;

                    Entidades.AddObject("NFe_Produtos", Produtos);
                    Entidades.SaveChanges();
                    Produtos = null;
                    Novo = null;
                }
                catch (Exception Ex)
                {
                    MessageBox.Show(Ex.Message.ToString());
                }
            }
        }

        public void CarregaProdutosLista(string pCodigo)
        {
            lstProdutos.Items.Clear();
            totalV = 0;


            int Codigo = int.Parse(pCodigo);
            var ProdsB = (from p in Entidades.NFe_Produtos
                          where p.nNFe == Codigo
                          select p).ToList();
            int i = 1;

            foreach (NFe_Produtos Ped in ProdsB)
            {

                ListViewItem item = new ListViewItem();
                if (Ped.prod_Baixado == "SIM")
                {
                    item.BackColor = Color.GreenYellow;
                }
                item.Text = Ped.prod_Controle.ToString();
                item.SubItems.Add(i.ToString());
                item.SubItems.Add(Ped.prod_cProd);
                item.SubItems.Add(Ped.prod_xProd);
                item.SubItems.Add(Ped.prod_uCOM);
                item.SubItems.Add(Ped.prod_qCOM.ToString("N", nfi));
                item.SubItems.Add(Ped.prod_vUnCOM.ToString("N", nfi));
                decimal Total = Ped.prod_qCOM * Ped.prod_vUnCOM;
                item.SubItems.Add(Total.ToString("N", nfi));
                lstProdutos.Items.Add(item);
                decimal preco = Ped.prod_vUnCOM;
                totalV = totalV + Total;

                //totalP = totalP + peso;
                i++;
            }
            lblValorNota.Text = totalV.ToString("N", nfi);
            
        }
        public void CalculoDesconto(string pProcentagem, string pValorTotal)
        {
            if (pProcentagem == "")
            {
                pProcentagem = "0";
            }
            decimal Porcentagem = decimal.Parse(pProcentagem);
            decimal ValorTotal = decimal.Parse(pValorTotal);
            if (Porcentagem == 0)
            {
                //lblDiferenca.Text = "0";
                lblValorComDesconto.Text = ValorTotal.ToString("N", nfi);
            }
            else
            {
                decimal ValorDesconto = ValorTotal * Porcentagem / 100;
                //lblDiferenca.Text = ValorDesconto.ToString("N", nfi);
                decimal ValorFinal = ValorTotal - ValorDesconto;
                lblValorComDesconto.Text = ValorFinal.ToString("N", nfi);
            }
        }
        public void CarregaProdutosListaOriginal(string pCodigo)
        {
            lstProdutos.Items.Clear();
            int CodigoPedido = int.Parse(pCodigo);
            var Prods = (from p in Entidades.PedidoDetalhes
                         where p.item_ped_codigo.Equals(CodigoPedido)
                         select p).ToList();
            decimal totalV = 0;
            decimal preco = 0;
            decimal peso = 0;
            decimal totalP = 0;
            int i = 1;
            NumberFormatInfo nfi = new CultureInfo("pt-br", false).NumberFormat;
            nfi.CurrencyDecimalDigits = 2;
            foreach (PedidoDetalhes Ped in Prods)
            {

                ListViewItem item = new ListViewItem();
                CodigoItem = Ped.item_codigo;
                item.Text = Ped.item_codigo.ToString();
                item.SubItems.Add(i.ToString());
                item.SubItems.Add(Ped.Produtos.NomeProduto);
                if (Ped.item_quantidade_final != null)
                {
                    item.SubItems.Add(Ped.item_quantidade_final.ToString());
                }
                else
                {
                    item.SubItems.Add(Ped.item_quantidade.ToString());
                }
                item.SubItems.Add(Ped.item_unidade);
                item.SubItems.Add(Ped.item_largura.ToString());
                item.SubItems.Add(Ped.item_altura.ToString());
                item.SubItems.Add(Ped.item_espessura.ToString());
                item.SubItems.Add(Ped.item_valor_kg.Value.ToString("N", nfi));
                if (Ped.item_valor_milheiro != null)
                {
                    item.SubItems.Add(Ped.item_valor_milheiro.Value.ToString("N", nfi));
                }
                else
                {
                    item.SubItems.Add("0");
                }
                item.SubItems.Add(Ped.item_peso_total.ToString());
                item.SubItems.Add(Ped.item_valor_total.Value.ToString("N", nfi));
                item.SubItems.Add(Ped.item_codigo.ToString());
                lstProdutosOriginal.Items.Add(item);
                string Vvalor = item.SubItems[10].Text;
                string Vpeso = item.SubItems[9].Text;
                preco = decimal.Parse(Vvalor);
                peso = decimal.Parse(Vpeso);
                totalV = totalV + preco;
                totalP = totalP + peso;
                i++;
            }
            //LimpaCampos();
            //txtValorPedido.Text = totalV.ToString("N", nfi);
            //nfi.NumberDecimalDigits = 3;
            //txtPesoPedido.Text = totalP.ToString("N", nfi);


        }

        private void VerificaEmissao(string Codigo)
        {
            if (Codigo != string.Empty)
            {
                int CodigoP = int.Parse(Codigo);

                var BuscaPedido = Entidades.PedidoCabeca.Where(ped => ped.CodigoPedido == CodigoP).FirstOrDefault();

                if (BuscaPedido.cStat == 100)
                {
                    MessageBox.Show("Essa nota já foi emitida, só será possível reimprimir a mesma!", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    btnReimprimir.Enabled = true;
                    btnEmitirNota.Enabled = false;
                }
            }
        }

        private void CarregaCFOPNota()
        {
            using(SiavEntities Entidades = new SiavEntities())
            {
                try
                {
                    var CFOPs = Entidades.CFOP.ToList();
                    cboCFOP.DataSource = CFOPs;
                    cboCFOP.DisplayMember = "cfop_nome";
                    cboCFOP.ValueMember = "cfop_numero";
                }
                catch
                {

                }
            }
        }

        private void frmEmiteNFe_Load(object sender, EventArgs e)
        {
            VerificaEmissao(CodigoPedido);
            CarregaProdutosListaOriginal(CodigoPedido);
            CopiaProdutosTab(CodigoPedido);
            CarregaPedidoParaBaixa(CodigoPedido);
            CarregaCFOPNota();
        }

        private void txtPorcentagemDesconto_TextChanged(object sender, EventArgs e)
        {
            CalculoDesconto(txtPorcentagemDesconto.Text, lblValorParaCalculo.Text);
        }

        private void btnEmitirNota_Click(object sender, EventArgs e)
        {
            if (MessageBox.Show("Tem certeza que deseja emitir a NF-e?", "Questão", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
            {

                ClassesTransporte.Empresa.IdEmpresa = 0;
                new FrmSelecaoEmpresa().ShowDialog();

                Util objNFeUtil = new Util();
                try
                {
                    ////////////////////////////////////////////////////

                    ///////////////////////////////////////////////////
                    int NFPedido = int.Parse(CodigoPedido);
                    var SQLPedido = Entidades.PedidoCabeca.FirstOrDefault(ped => ped.CodigoPedido.Equals(NFPedido));
                    var Parametros = Entidades.Parametros.FirstOrDefault();
                    var Empresa = Entidades.Empresa.FirstOrDefault(codigoempresa => codigoempresa.Ccodigo == ClassesTransporte.Empresa.IdEmpresa);
                    var NNFe = (from NF in Entidades.tabNFe
                                orderby NF.NFeCampo descending
                                select NF).FirstOrDefault();
                    int nNF = NNFe.NFeCampo + 1;
                    //NNFe.NFeCampo = nNF;
                    //Entidades.ObjectStateManager.ChangeObjectState(NNFe, EntityState.Modified);
                    //Entidades.SaveChanges();
                    string Certificado = Parametros.Certificado;

                    //
                    //
                    //====== instancia DLL==================
                    //

                    //Dim objNFeUtil As NFe_Util.Util

                    //Set objNFeUtil = New NFe_Util.Util
                    //
                    //         criação dos grupos
                    //
                    //===================grupo de identificação do emitente (grupo B do Manual de integração - páginas 90)=======================
                    //
                    //        <>&" são caracteres reservados do XML e devem ser evitados ou substituídos
                    //        por &lt; &gy; &amp; &quot;
                    //
                    //        Vale ressaltar que as aplicações das UF devem mostrar DIAS &amp; DIAS TENTANDO S/A,
                    //        pois não entedem &amp; como &, assim talvez seja melhor substituir o & por e.
                    //
                    emi_CNPJ = Validacoes.removeFormatacao(Validacoes.TirarAcento(Empresa.CNPJ));
                    // CNPJ do emitente sem máscara de formatação
                    emi_CPF = "";
                    // CPF do emitente, uso exclusivo do Fisco
                    emi_xNome = Validacoes.TirarAcento(Empresa.xNome);
                    // Razão social do emitente, evitar caracteres acentuados e &
                    emi_xFant = Validacoes.TirarAcento(Empresa.xFant);
                    // Nome fantasia
                    emi_xLgr = Validacoes.TirarAcento(Empresa.xLgr);
                    // logradouro
                    emi_nro = Validacoes.TirarAcento(Empresa.nro);
                    // número, informar S/N quano inexistente para erro de Schema XML
                    emi_xCpl = "";
                    // complemento do endereço, o conteúdo pode ser omitido
                    emi_xBairro = Validacoes.TirarAcento(Empresa.xBairro);
                    // bairro
                    emi_cMun = Empresa.cMun.ToString();
                    // código do município (vide página 141 do manual), deve ser compatível com a UF
                    emi_xMun = Validacoes.TirarAcento(Empresa.xMun);
                    // nome do município
                    emi_UF = Empresa.UF;
                    // sigla da UF
                    emi_CEP = Validacoes.removeFormatacao(Validacoes.TirarAcento(Empresa.CEP));
                    // CEP - sem máscara
                    emi_cPais = "1058";
                    // código do pais - deve fixo em 1058 - Brasil
                    emi_xPais = "Brasil";
                    // nome do pais (Brasil ou BRASIL)
                    emi_fone = Validacoes.removeFormatacao(Empresa.fone);
                    // número do telefone sem máscara
                    emi_IE = Validacoes.removeFormatacao(Empresa.IE);
                    // Inscrição Estadual do emitente sem máscara
                    emi_IEST = "";
                    // Inscrição Estadual do ST
                    emi_IM = "";
                    // Inscrição Municipal
                    emi_CNAE = "";
                    // Código do CNAE
                    emi_CRT = "3";
                    //informar o Código de Regime Tributário - CRT, valores válidos: 1 - Simples Nacional; 2 - Simples Nacional - excesso de sublimite de receita bruta; 3 - Regime Normal 
                    //
                    //       gera grupo emi
                    //
                    emi = objNFeUtil.emitente2G(emi_CNPJ, emi_CPF, emi_xNome, emi_xFant, emi_xLgr, emi_nro, emi_xCpl, emi_xBairro, emi_cMun, emi_xMun, emi_UF, emi_CEP, emi_cPais, emi_xPais, emi_fone, emi_IE, emi_IEST, emi_IM, emi_CNAE, emi_CRT);

                    //MsgBox "Grupo do emitente " + emi, vbInformation, "Resultado"

                    //
                    //========grupo de identificação da NF-e - grupo B do Manual de integração - páginas 86 a 89
                    //
                    ide_cUF = Parametros.cUF;
                    // código da UF - tabela do IBGE: 35 - SP, 43 - RS, etc. (vide página 141 do manual)
                    if (cboCFOP.SelectedValue.ToString() == "6915")
                    {
                        ide_natOp = "Manutencao";
                    }
                    else
                    {
                        ide_natOp = "Venda";
                    }
                        
                    // naturez da operação
                    ide_indPag = 0;
                    // 0=pagamento à vista
                    ide_mode = Parametros.mod;
                    // modelo da nota fiscal eletronica
                    ide_serie = Parametros.serie;
                    // série única = 0
                    ide_nNF = nNF;
                    // número da NF-e
                    ide_dEmi = DateTime.Now;
                    // data de emissão
                    ide_dSaiEnt = DateTime.Now;
                    // data em branco = 30/12/1899
                    ide_tpNF = 1;
                    // Tipo de Nota Fiscal => 0 = entrada / 1 = Saida
                    ide_cMunFG = Parametros.cMunFG.ToString();
                    // código do município do IBGE de ocorrência do FG do ICMS (vide página 141 do manual)
                    ide_tpImp = 1;
                    // orientação da impressão 1-retrato/2-paisagem
                    ide_tpAmb = Parametros.tpAmb;
                    // ambiente de envio da NF-e 1-produção / 2 - homologação
                    ide_finNFe = 1;
                    // finalidade da emissão da NF-e 1- NF-e normal
                    ide_tpEmis = 1;
                    // forma de emissão da NF-e 1- normal, 2 - contingência FS, 3 - contingência SCAN, etc.
                    ide_procEmi = 0;
                    // identificação do processo de emissão da NF-e 0 - aplicação do contribuinte
                    ide_verProc = "2.00";
                    // identificação da vesão do processo de emissão
                    ide_NFref = "";
                    // NF referenciada
                    //
                    //     gera a chave de acesso da NF-e
                    //
                    //     utilizar a função criaChaveNFe para gerar a chave de acesso, código da NF-e e DV
                    //
                    //=========variáveis de trabalho
                    //
                    //
                    int resultado = 0;

                    string cUF = null;
                    string ano = null;
                    string mes = null;
                    string modelo = null;
                    string serie = null;
                    string numero = null;
                    string codigoSeguranca = null;
                    string msgResul = null;
                    string cNF = null;
                    string cDV = null;
                    cUF = Strings.Trim(Conversion.Str(ide_cUF));
                    //DateTime MyAno = ide_dEmi
                    ano = ide_dEmi.ToString("yy");
                    mes = ide_dEmi.Month.ToString();
                    modelo = ide_mode.ToString();
                    serie = ide_serie.ToString();
                    numero = ide_nNF.ToString();
                    msgResul = "";
                    codigoSeguranca = "segredo";
                    cNF = "";
                    cDV = "";
                    ChaveNFe = "";

                    if (objNFeUtil.CriaChaveNFe2G(cUF, ano, mes, emi_CNPJ, modelo, serie, numero, ide_tpEmis.ToString(), codigoSeguranca, out msgResul, out cNF,
                    out cDV, out ChaveNFe) != 5601)
                    {
                        MessageBox.Show("Ocorreu um erro ao gerar a chave de acesso " + msgResul, "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }

                    ide_cNF = int.Parse(cNF);
                    // código numérico que compõe a chave de acesso
                    ide_cDV = int.Parse(cDV);
                    // DV da chave de acesso da NF-e
                    //
                    //   gera grupo ide
                    //
                    ide = objNFeUtil.identificador2G(ide_cUF, ide_cNF, ide_natOp, ide_indPag, ide_mode, ide_serie, ide_nNF, ide_dEmi, ide_dSaiEnt, ide_hSaiEnt, ide_tpNF,
                    ide_cMunFG, ide_NFref, ide_tpImp, ide_tpEmis, ide_cDV, ide_tpAmb, ide_finNFe, ide_procEmi, ide_verProc, ide_dhCont, ide_xJust);
                    //
                    //
                    //================grupo de identificação do destinatario (grupo E do Manual de integração - páginas 92)=======================
                    //
                    //        <>&" são caracteres reservados do XML e devem ser evitados ou substituídos
                    //        por &lt; &gy; &amp; &quot;
                    //
                    //        Vale ressaltar que as aplicações das UF devem mostrar DIAS &amp; DIAS TENTANDO S/A,
                    //        pois não entedem &amp; como &, assim talvez seja melhor substituir o & por e.
                    //
                    if (SQLPedido.Clientes.CPF_CNPJ.Length > 11)
                    {
                        dest_CNPJ = Validacoes.removeFormatacao(Validacoes.TirarAcento(SQLPedido.Clientes.CPF_CNPJ));
                    }
                    else
                    {
                        // CNPJ do destinatario sem máscara de formatação
                        dest_CPF = Validacoes.removeFormatacao(Validacoes.TirarAcento(SQLPedido.Clientes.CPF_CNPJ));
                        // CPF do destinatario, uso exclusivo do Fisco
                    }

                    dest_xNome = Validacoes.TirarAcento(SQLPedido.Clientes.RazaoSocial);
                    // Razão social do destinatario, evitar caracteres acentuados e &
                    dest_xFant = Validacoes.TirarAcento(SQLPedido.Clientes.NomeFantasia);
                    // Nome fantasia
                    dest_xLgr = Validacoes.TirarAcento(SQLPedido.Clientes.EELogradouro);
                    // logradouro
                    dest_nro = Validacoes.TirarAcento(SQLPedido.Clientes.EENumero);
                    // número, informar S/N quano inexistente para erro de Schema XML
                    dest_xCpl = Validacoes.TirarAcento(SQLPedido.Clientes.EEComplemento);
                    // complemento do endereço, o conteúdo pode ser omitido
                    dest_xBairro = Validacoes.TirarAcento(SQLPedido.Clientes.EEBairro);
                    // bairro
                    dest_cMun = SQLPedido.Clientes.ECCidade.ToString();
                    int CodigoCidade = int.Parse(SQLPedido.Clientes.EECidade.ToString());
                    // código do município (vide página 141 do manual), deve ser compatível com a UF
                    var NomeCidade = Entidades.MunicipiosIBGE.FirstOrDefault(Mun => Mun.Municipio.Equals(CodigoCidade));
                    dest_xMun = Validacoes.TirarAcento(NomeCidade.NomeMunicipio);
                    // nome do município
                    dest_UF = Validacoes.TirarAcento(NomeCidade.SiglaUF);
                    // sigla da UF
                    dest_CEP = Validacoes.removeFormatacao(SQLPedido.Clientes.EECEP);
                    // CEP - sem máscara
                    dest_cPais = "1058";
                    // código do pais - deve fixo em 1058 - Brasil
                    dest_xPais = "Brasil";
                    // nome do pais (Brasil ou BRASIL)
                    dest_fone = Validacoes.removeFormatacao(SQLPedido.Clientes.Telefone);
                    // número do telefone sem máscara
                    dest_IE = SQLPedido.Clientes.IE_RG;
                    // Inscrição Estadual do destinatario sem máscara
                    dest_IESUF = "";
                    // Inscrição SUFRAMA
                    dest_Email = SQLPedido.Clientes.Email;
                    //
                    //   gera grupo do destinatário
                    //
                    dest = objNFeUtil.destinatario2G(dest_CNPJ, dest_CPF, dest_xNome, dest_xLgr, dest_nro, dest_xCpl, dest_xBairro, dest_cMun, dest_xMun, dest_UF,
                    dest_CEP, dest_cPais, dest_xPais, dest_fone, dest_IE, dest_IESUF, dest_Email);
                    //MsgBox "Grupo de destinatário " + dest, vbInformation, "Resultado"
                    //
                    //====== Valor Dim total da NF-e ============
                    //
                    totICMS_vBC = 0;
                    totICMS_vICMS = 0;
                    totICMS_vBCST = 0;
                    totICMS_vST = 0;
                    totICMS_vProd = 0;
                    totICMS_vFrete = 0;
                    totICMS_vSeg = 0;
                    totICMS_vDesc = 0;
                    totICMS_vII = 0;
                    totICMS_vIPI = 0;
                    totICMS_vPIS = 0;
                    totICMS_vCOFINS = 0;
                    totICMS_vOutro = 0;
                    totICMS_vNF = 0;
                    //
                    //
                    //================grupo de detalhe do produto (grupo I01 do Manual de integração - páginas 95)=======================
                    //
                    //
                    int Codigo = int.Parse(CodigoPedido);
                    var ProdsB = (from p in Entidades.NFe_Produtos
                                  where p.nNFe == Codigo
                                  select p).ToList();
                    int contador = 1;
                    foreach (NFe_Produtos Prods in ProdsB)
                    {
                        Prod_cProd = Prods.prod_cProd;
                        // código do produto
                        Prod_cEAN = "";
                        // código EAN (0, 8,12, 13 ou 14 caracteres), o conteúdo pode ser omitido se não tiver EAN
                        Prod_xProd = Prods.prod_xProd;
                        // código do produto, espaços em branco consecutivos ou no início ou fim do campo podem gerar erro de Schema XML, além de caracteres reservados do XML <>&"'
                        Prod_NCM = "39239000";
                        // código NCM, pode ser omitido se não sujeito ao IPI
                        Prod_ExTIPI = "";
                        // ExTipi, especialização do código NCM, informar apenas se existir
                        Prod_genero = 0;
                        // informar as duas primeiras posições do NCM
                        Prod_CFOP = Convert.ToInt32(cboCFOP.SelectedValue.ToString());
                        // CFOP do operação, causa erro de XML se informado um código inexistente
                        Prod_uCOM = Prods.prod_uCOM;
                        // unidade de comercialização                        
                        Prod_qCom = Prods.prod_qCOM.ToString("0.00");
                        // quantidade de comercialização
                        Prod_vUnCom = Prods.prod_vUnCOM.ToString("0.00");
                        // valor unitário de comercialização, campo de mera demonstração deve ser o resultado da divisão do vProd / qCom
                        decimal soma = Prods.prod_vUnCOM * Prods.prod_qCOM;
                        ///////////////////////////////////////////////////////////
                        Prod_vProd = double.Parse(soma.ToString());
                        // valor do total do item
                        Prod_cEANTrib = "";
                        // código EAN (0, 8,12, 13 ou 14 caracteres), o conteúdo pode ser omitido se não tiver EAN, em geral é o mesmo código do EAN de comercialização
                        Prod_uTrib = Prods.prod_uTriv;
                        // unidade de tributação, na maioria dos casos é idêntico  ao vUnCom, pode diferente nos casos de produtos sujeitos a ST em que a unidade de pauta é diferente da unidade de comercialização
                        // Ex. unidade de comercialização = 1 pack de lata de cerveja => unidade de tributação = 1 lata (preço de pauta)
                        Prod_qTrib = Prods.prod_qCOM.ToString("0.00");
                        // quantidade de comercialização
                        Prod_vUnTrib = Prods.prod_vUnCOM.ToString("0.00");
                        // valor unitário de tributação, campo de mera demonstração deve ser o resultado da divisão do vProd / qTrib
                        Prod_vFrete = 0;
                        // valor do frete, se cobrado do cliente deve ser rateado entre os itens de produto
                        Prod_vSeguro = 0;
                        // valor do seguro, se cobrado do cliente deve ser rateado entre os itens de produto
                        prod_Vdesc = 0;
                        // valor do desconto concedido
                        Prod_indTot = 1;
                        //Este campo deverá ser preenchido com: 0 – o valor do item (vProd) não compõe o valor total da NF-e (vProd) 1 - o valor do item (vProd) compõe o valor total da NF-e.
                        Prod_DI = "";
                        // dados da importação, informar apenas no caso de NF de entrada (importação)
                        Prod_DetEspecifico = "";
                        // dados específicos, informar para medicamento, veículos novos, armamentos e combustíveis.
                        Prod_infAdProd = "";
                        // informações adicionais do produto
                        //
                        //   gera grupo do destinatário
                        //
                       
                        //////////////////////////////////////////////////////////////////////////////////////////
                        double TotalProd = 0;
                        
                        //MsgBox "Grupo de produto " + prod, vbInformation, "Resultado"
                        //
                        //
                        //=========dados do ICMS (grupo N01 do Manual de integração - páginas 100)=====================
                        //
                        icms_pRedBC = 0;
                        // percentual de redução da BC
                        icms_vBC = 0;
                        // valor da BC do ICMS = vProd + vFrete + vSeguro
                        icms_pICMS = 0;
                        // alíquota do ICMS
                        icms_vICMS = 0;
                        // valor do ICMS

                        // percentual do ICMSST
                        if (cboCFOP.SelectedValue.ToString() == "5401")
                        {    
                            ///////////////////////////////////////////////////////////////////////////////
                            //QUANDO O CFOP FOR 5401: cst - 10 excluir 6401
                            ///////////////////////////////////////////////////////////////////////////////
                            icms_orig = "0";                                                             //
                            icms_CST = "10";// "30";                                                    //
                            double ValorBCST = Prod_vProd;                                               //
                            ///////////////////////////////////////////////////////////////////////////////
                            // Tabela B - CST=00-tributação normal
                            //icms_modBC = 0;
                            // modalidade de determinação da BC = 3-valor da operação
                            icms_modBCST = 4;
                            //icms_modBCST = 0;
                            // modalidade de determinação da BC ICMS ST
                            icms_pmVAST = 38;
                            // percentual de valor de margem e valor adicionado
                            icms_pRedBCST = 17;
                            // percentual de redução da BC do ICMS ST
                            ////////////////////////////////////////////////////////////////////////////////
                            // modalidade de determinação da BC ICMS ST
                            icms_BCST = ValorBCST;
                            icms_pICMSST = 17;
                            ValordoICMSST = icms_BCST * 0.38 * 0.17;
                            icms_vICMSST = ValordoICMSST;
                            ///////////////////////////////////////////////
                            //TotalProd = Prod_vProd + icms_vICMSST; //norma 2011-05
                            ///////////////////////////////////////////////                            
                            //double SomaTudo = ValorBCST * 0.38;
                            ///////////////////////////////////////////////
                            //icms_BCST = SomaTudo;
                        }
                        else
                        {
                            icms_pICMSST = 0;
                            icms_BCST = 0;
                        }
                        // Tabela A - origem da mercadoria 0=nacional

                        if (cboCFOP.SelectedValue.ToString() == "5101" || cboCFOP.SelectedValue.ToString() == "6915")
                        {
                            icms_orig = "0";
                            icms_CST = "90";
                        }

                        if (cboCFOP.SelectedValue.ToString() == "6101")
                        {
                            icms_orig = "0";
                            icms_CST = "00";
                            icms_modBC = 1; //MODELO DA BASE DE CALCULO
                            icms_vBC = Prod_vProd; // VALOR DA BASE DE CALCULO
                            icms_pICMS = 12; // PERCENTUAL DO ICMS
                            icms_vICMS = Prod_vProd * 0.12;
                        }
                        // valor do ICMS ST devido
                        //
                        //   gera grupo do ICMS
                        //
                        if (TotalProd != 0)
                        {
                            Prod_vProd = TotalProd;

                            //string icms = objNFeUtil.icms2G()
                            //double ValordoProduto = TotalProd / (double)Prods.prod_qCOM; //VALOR DO PRODUTO COM SUBSTITUIÇÃO TRIBUTARIA
                            prod = objNFeUtil.produto2G(Prod_cProd, Prod_cEAN, Prod_xProd, Prod_NCM, Prod_ExTIPI, Prod_CFOP, Prod_uCOM, Prod_qCom, Prod_vProd.ToString("0.00"),
                            Prod_vProd, Prod_cEANTrib, Prod_uTrib, Prod_qTrib, Prod_vUnTrib, Prod_vFrete, Prod_vSeguro, prod_Vdesc, Prod_vOutro, Prod_indTot, Prod_DI, prod_detestpecifico, Prod_XPed, Prod__nItemPed);
                        }
                        else
                        {
                            prod = objNFeUtil.produto2G(Prod_cProd, Prod_cEAN, Prod_xProd, Prod_NCM, Prod_ExTIPI, Prod_CFOP, Prod_uCOM, Prod_qCom, Prod_vUnCom,
                            Prod_vProd, Prod_cEANTrib, Prod_uTrib, Prod_qTrib, Prod_vUnTrib, Prod_vFrete, Prod_vSeguro, prod_Vdesc, Prod_vOutro, Prod_indTot, Prod_DI, prod_detestpecifico, Prod_XPed, Prod__nItemPed);
                        }
                        /////////////////////////////////////////////////////////////////////////
                        if (ValordoICMSST != 0)
                        {
                            icms = objNFeUtil.icms2G(icms_orig, icms_CST, icms_modBC, icms_pRedBC, icms_vBC, icms_pICMS, icms_vICMS, icms_vmodbcst, icms_pmVAST, icms_pRedBCST,
                            icms_BCST, icms_pICMSST, icms_vICMSST, vBCSTRet, vICMSSRet, vBCSTDest, vICMSSTDest, motDesICMS, pBCOp, UFST, pCredSN, vCredICMSSN);
                        }
                        else
                        {
                            icms = objNFeUtil.icms2G(icms_orig, icms_CST, icms_modBC, icms_pRedBC, icms_vBC, icms_pICMS, icms_vICMS, icms_vmodbcst, icms_pmVAST, icms_pRedBCST,
                           icms_BCST, icms_pICMSST, icms_vICMSST, vBCSTRet, vICMSSRet, vBCSTDest, vICMSSTDest, motDesICMS, pBCOp, UFST, pCredSN, vCredICMSSN);
                        }

                        //MsgBox "Grupo de Tributos/ICMS " + icms, vbInformation, "Resultado"

                        //
                        //=========dados do PIS (grupo Q do Manual de Integração - páginas 110) =============
                        //
                        pis_CST = "06";
                        pis_vBC = 0;
                        pis_pPIS = 0;
                        pis_vPIS = 0;
                        pis_qBCProd = 0;
                        pis_vAliqProd = 0;
                        //
                        //   gera grupo do PIS
                        //
                        string PIS = objNFeUtil.PIS(pis_CST, pis_vBC, pis_pPIS, pis_vPIS, pis_qBCProd, PIS_AliqProd);

                        //MsgBox "Grupo de Tributos/PIS " + PIS, vbInformation, "Resultado"

                        //
                        //========dados do COFINS (grupo s do Manual de Integração - páginas 113) ============
                        //
                        cofins_CST = "06";
                        cofins_vBC = 0;
                        cofins_pCOFINS = 0;
                        cofins_vCOFINS = 0;
                        cofins_qBCProd = 0;
                        cofins_vAliqProd = 0;
                        //
                        //   gera grupo do PIS
                        //
                        string COFINS = objNFeUtil.COFINS(cofins_CST, cofins_vBC, cofins_pCOFINS, cofins_vCOFINS, cofins_qBCProd, cofins_AliqProd);

                        //MsgBox "Grupo de Tributos/COFINS " + COFINS, vbInformation, "Resultado"

                        //
                        //========dados do IMPOSTO (grupo M do Manual de Integração - páginas 100) ============
                        //
                        string imposto = objNFeUtil.imposto(icms, "", "", PIS, "", COFINS, "", "");
                        //
                        //   atualização de total
                        //
                        totICMS_vBC = totICMS_vBC + icms_vBC;
                        totICMS_vICMS = totICMS_vICMS + icms_vICMS;
                        totICMS_vBCST = totICMS_vBCST + icms_BCST;
                        totICMS_vST = totICMS_vST + icms_vICMSST;
                        totICMS_vProd = totICMS_vProd + Prod_vProd;
                        totICMS_vFrete = totICMS_vFrete + Prod_vFrete;
                        totICMS_vSeg = totICMS_vSeg + prod_vSeg;
                        totICMS_vDesc = totICMS_vDesc + prod_Vdesc;

                        //MsgBox "Grupo de Tributos/COFINS " + COFINS, vbInformation, "Resultado"
                        //
                        //========dados do ITEM do detalhe (grupo H do Manual de Integração - páginas 95) ============
                        //
                        //  item 1
                        //
                        if (contador == 1)
                        {
                            detalhes = objNFeUtil.detalhe(contador, prod, imposto, Prod_infAdProd);
                        }
                        if (contador > 1)
                        {
                            detalhes = detalhes + objNFeUtil.detalhe(contador, prod, imposto, Prod_infAdProd);
                        }
                        contador++;
                    }

                    totICMS_vNF = totICMS_vProd + totICMS_vFrete + totICMS_vSeg - totICMS_vDesc + totICMS_vST;
                    // verificar outros acréscimos e descontos
                    //
                    //
                    //
                    totICMS = objNFeUtil.totalICMS(totICMS_vBC, totICMS_vICMS, totICMS_vBCST, totICMS_vST, totICMS_vProd, totICMS_vFrete, totICMS_vSeg, totICMS_vDesc, totICMS_vII, totICMS_vIPI,
                    totICMS_vPIS, totICMS_vCOFINS, totICMS_vOutro, totICMS_vNF);

                    total = objNFeUtil.total(totICMS, "", "");
                    // total da NF-e sem os valors de ISSQN e RetTributos

                    //
                    //DADOS DO TRANSPORTADOR
                    //
                    string Transportadora = "";
                    string VolumesXML = "";
                    var vTranporte = Entidades.Transportadoras.Where(tr => tr.TCodigo == SQLPedido.Clientes.TransportadoraPadrao).FirstOrDefault();
                    if (vTranporte != null)
                    {
                        string vDocumento = Validacoes.removeFormatacao(vTranporte.CPFCNPJ);
                        if (vDocumento.Length > 11)
                        {
                            TranspCNPJ = Validacoes.removeFormatacao(vTranporte.CPFCNPJ);
                        }
                        else
                        {
                            TranspCPF = Validacoes.removeFormatacao(vTranporte.CPFCNPJ);
                        }
                        string TranspNome = Validacoes.TirarAcento(vTranporte.NomeRazao);
                        string TranspIE = Validacoes.removeFormatacao(vTranporte.IERG);
                        string TranspEndereco = Validacoes.TirarAcento(vTranporte.Logradouro);
                        string TranspCidade = Validacoes.TirarAcento(vTranporte.MunicipiosIBGE.NomeMunicipio);
                        string TranspEstado = Validacoes.TirarAcento(vTranporte.MunicipiosIBGE.SiglaUF.ToUpper());
                        ///////////////////////////////////////////////////
                        //Volumes//
                        //////////////////////////////////////////////////
                        double Volumes = double.Parse(SQLPedido.NVolumes);
                        VolumesXML = objNFeUtil.vol(Volumes, "", "INPLAST", "", 0, 0, "");
                        //////////////////////////////////////////////////
                        Transportadora = objNFeUtil.transporta(TranspCNPJ, TranspCPF, TranspNome, TranspIE, TranspEndereco, TranspCidade, TranspEstado);
                        ////////////////////////////////////////////////////
                    }
                    transpModFrete = SQLPedido.ModalidadeFrete;
                    // responsabilidade do frete 0-emitente, 1-destinatário
                    transp = objNFeUtil.transportador2G(transpModFrete, Transportadora, "", "", "", "", "", VolumesXML);

                    //
                    //==============informações adcionais
                    //
                    //infAdic_infAdiFisco = "NF-eletronica.com/blog - visite o blog da NF-e";
                    //infAdic_infAdi_infCpl = "NF-e emitida em aplicacao DEMO em VB 6.0";
                    //infAdic = objNFeUtil.infAdic(infAdic_infAdiFisco, infAdic_infAdi_infCpl, "", "", "");
                    //
                    //=============consolida a NF-e=================
                    //

                    infAdic_infAdiFisco = "DOCUMENTO EMITIDO POR ME OU EPP OPTANTE PELO SIMPLES NACIONAL, NAO GERA DIREITO A CREDITO FISCAL DE IPI";

                    infAdic_infCPL = Utilidades.NFETextoObs;
                    //infAdic_infCPL = SQLPedido.Observacoes;
                    infAdic = objNFeUtil.infAdic2G("",infAdic_infCPL,"","","");

                    versao = "2.00";
                    NFe = objNFeUtil.NFe2G(versao, ChaveNFe, ide, emi, "", dest, retirada, entrega, detalhes, total,
                    transp, cobr, infAdic, exporta, compra, vCana);

                    /////////////////////////////
                    //txtRetorno.Text = NFe;

                    ////////////////////////////////////////////////////////////////////////////////
                    //string Caminho2 = @"C:\Envio\";
                    //string vCertificado = "";
                    //string msnResulCert = "";
                    //var ResultCert = objNFeUtil.PegaNomeCertificado(ref vCertificado, out msnResulCert);
                    //MessageBox.Show(ResultCert.ToString() + msnResulCert);
                    //StreamWriter Gambi = new StreamWriter(Caminho2 + "certificato.txt");
                    //Gambi.Write(Certificado.ToString());
                    //Gambi.Close();
                    //////////////////////////////////////////////////////////////////////////////
                    int ResultadoAssinatura;
                    string msgResultadoAss = "";
                    string XMLAssinado = objNFeUtil.Assinar(NFe, "infNFe", Certificado, out ResultadoAssinatura, out msgResultadoAss);
                    /////////////////////////////////////////////////////////////////////////////////
                    //string XML;       //' informar o xml a ser validado
                    //int tipXML;      //' tipo do XML a ser validado (Ex. 1 = NF-e assinada versão 1.10 (nfe_v1.10.xsd)
                    int qtdeErros;    //' quantide de Erros de validação
                    string erroXML;// As String       ' retorna com uma string com os erros de validação
                    string msgResultado;// As String  ' literal com resultado da chamada da DLL


                    //XML = XMLAssinado.ToString();
                    var Resultadod = objNFeUtil.ValidaXML(XMLAssinado, 19, out msgResultado, out qtdeErros, out erroXML);
                    if (Resultadod == 5501)
                    {
                    //    MessageBox.Show("Tudo OK");
                    }
                    else
                    {
                        MessageBox.Show(String.Format("Erro {0} e {1}", erroXML, msgResultado));
                    }


                    string msgDosDados = "";
                    string RetWebService = "";
                    int statusWebService;
                    string Resultado = "";
                    string nroRecibo = "";
                    string dhRecebimento = "";
                    string tMed = "";
                    this.Cursor = Cursors.WaitCursor;
                    string NFeAssinada = objNFeUtil.EnviaNFe2G("MT", ref NFe, Certificado, "2.00", out msgDosDados, out RetWebService, out statusWebService, out Resultado, out nroRecibo, out dhRecebimento, out tMed, "", "", "", "a907ec9e495ff56bb33991edf9ffdb7a29410493a560cd66af94dd685715840d5367736393bf27a2a4d49cbdefe93035b0c88e50e61ace4847fa57b742366b03");
                    this.Cursor = Cursors.Default;


                    if (statusWebService == 103)
                    {
                        MessageBox.Show("Nota Fiscal eletronica Enviada com sucesso", "Informação", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        BuscarNFe.Enabled = true;

                        NNFe.NFeCampo = nNF;
                        Entidades.ObjectStateManager.ChangeObjectState(NNFe, EntityState.Modified);
                        Entidades.SaveChanges();
                        ////////////////////////////
                        //Atualiza dados da NFe na cabeça do pedido
                        ////////////////////////////
                        SQLPedido.NumNFe = nNF;
                        SQLPedido.ChaveNFe = ChaveNFe;
                        SQLPedido.XML_NFe = NFeAssinada;
                        SQLPedido.Num_Recibo = nroRecibo;
                        

                        Entidades.ObjectStateManager.ChangeObjectState(SQLPedido, EntityState.Modified);
                        Entidades.SaveChanges();
                        //////////////////////////////
                    }
                    else
                    {
                        MessageBox.Show("Houve um erro ao enviar a nota, o erro foi: " + Resultado);
                    }
                    objNFeUtil = null;
                }
                catch (Exception ex)
                {
                    MessageBox.Show("Erro ao emitir a NF-e " + ex.Message, "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    objNFeUtil = null;
                }

            }
            GC.Collect();
        }        

        private void btnAlterar_Click(object sender, EventArgs e)
        {

        }

        private void btnSalvarAlteracoes_Click(object sender, EventArgs e)
        {
            int CodigoItemSelecionado = int.Parse(lstProdutos.SelectedItems[0].Text);
            var Item = Entidades.NFe_Produtos.FirstOrDefault(pr => pr.prod_Controle.Equals(CodigoItemSelecionado));
            Item.prod_qCOM = decimal.Parse(txtQuantidade.Text);
            Item.prod_qTriv = txtQuantidade.Text;
            Item.prod_vUnCOM = decimal.Parse(txtValor.Text);
            Item.prod_vUnTrib = decimal.Parse(txtValor.Text);
            Item.prod_Baixado = "SIM";
            Entidades.ObjectStateManager.ChangeObjectState(Item, EntityState.Modified);
            Entidades.SaveChanges();
            CarregaProdutosLista(CodigoPedido);
            Validacoes.LimpaCamposFormulario(Controls);
        }

        private void lstProdutos_SelectedIndexChanged(object sender, EventArgs e)
        {
            try
            {
                //Selecionar a tabela de cima quando a de baixo for selecionada.
                //lstProdutosOriginal.SelectedItems[0].Text = lstProdutos.SelectedItems[0].Text;
                int CodigoItemSelecionado = int.Parse(lstProdutos.SelectedItems[0].Text);
                var Item = Entidades.NFe_Produtos.FirstOrDefault(pr => pr.prod_Controle.Equals(CodigoItemSelecionado));
                txtQuantidade.Text = Item.prod_qCOM.ToString("N", nfi);
                txtValor.Text = Item.prod_vUnCOM.ToString("N", nfi);
            }
            catch
            {
                //MessageBox.Show("Selecione um item da lista", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void BuscarNFe_Click(object sender, EventArgs e)
        {
            Util objNFeUtil = new Util();

            int NumeroPedidoNota = int.Parse(CodigoPedido);
            var Parametros = Entidades.Parametros.FirstOrDefault();
            var BuscaNota  = Entidades.PedidoCabeca.FirstOrDefault(ped => ped.CodigoPedido == NumeroPedidoNota);
            string Certificado = Parametros.Certificado;
            string XML_NFE = BuscaNota.XML_NFe;
            string nroRecibo = BuscaNota.Num_Recibo;
            string msgDados = "";
            string msgRetWS = "";
            int cStat;
            string msgResultado = "";
            string nroProtocolo = "";
            string dhProtocolo = "";
            string cMsg = "";
            string xMsg = "";
            string nfeProc = objNFeUtil.BuscaNFe2G("MT", Parametros.tpAmb, ref XML_NFE, nroRecibo, Certificado, "2.00", out msgDados, out msgRetWS, out cStat, out msgResultado, out nroProtocolo, out dhProtocolo, out cMsg, out xMsg, "", "", "", "a907ec9e495ff56bb33991edf9ffdb7a29410493a560cd66af94dd685715840d5367736393bf27a2a4d49cbdefe93035b0c88e50e61ace4847fa57b742366b03");

            /////////////////////////////
            if (cStat == 100)
            {
                string Resultado;
                BuscaNota.XML_NFe = nfeProc;
                BuscaNota.cStat = cStat;
                BuscaNota.ProtocoloDeAutorizacao = nroProtocolo;
                Entidades.ObjectStateManager.ChangeObjectState(BuscaNota, EntityState.Modified);
                Entidades.SaveChanges();
                MessageBox.Show("Autorizado o uso da NF-e", "Informação", MessageBoxButtons.OK, MessageBoxIcon.Information);
                var BuscarNota  = Entidades.PedidoCabeca.FirstOrDefault(ped => ped.CodigoPedido == NumeroPedidoNota);
                int GerarPDF = objNFeUtil.geraPdfDANFE(BuscarNota.XML_NFe, "", "S", "N", "N", "", "Z", "", out Resultado);
                
            }
            else
            {
                MessageBox.Show(String.Format("Erro {0} {1}", msgResultado, msgRetWS), "Informação", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }

            objNFeUtil = null;
            GC.Collect();
        }

        private void btnReimprimir_Click(object sender, EventArgs e)
        {
            int NumeroPedidoNota = int.Parse(CodigoPedido);
            var Parametros = Entidades.Parametros.FirstOrDefault();
            var BuscaNota = Entidades.PedidoCabeca.FirstOrDefault(ped => ped.CodigoPedido == NumeroPedidoNota);
            if (BuscaNota.cStat == 100)
            {
                try
                {
                    Util NFE = new Util();
                    string Resultado;

                    int GerarPDF = NFE.geraPdfDANFE(BuscaNota.XML_NFe, "", "S", "N", "N", "", "Z", "", out Resultado);  
                  
                    NFE = null;
                    ////////////////////////////////////////////////////////////////////////////////////                
                }
                catch (Exception ex)
                {
                    Validacoes.Erro("Erro ao gerar arquivo, o erro foi: " + ex.Message.ToString());
                }
            }
            else
            {
                Validacoes.Erro("Essa nota ainda não foi autorizada, não será possivel a reimpressão!");
            }

            GC.Collect();
        }

        private void btnCancelarNota_Click(object sender, EventArgs e)
        {

            try
            {
                int NumeroPedidoNota = int.Parse(CodigoPedido);
                Util objNFeUtil = new Util();
                Validacoes util = new Validacoes();
                using (SiavEntities Entidades = new SiavEntities())
                {
                    using (frmJustificativa Just = new frmJustificativa())
                    {
                        Just.ShowDialog();
                        Just.Dispose();
                        //int NumeroPedidoNota = int.Parse(Utilidades.NumeroPedido);
                        var Parametro = Entidades.Parametros.FirstOrDefault();
                        var BuscaNota = Entidades.PedidoCabeca.FirstOrDefault(ped => ped.CodigoPedido == NumeroPedidoNota);


                        ProcCancelNFE = objNFeUtil.CancelaNF2G("MT", Parametro.tpAmb, Parametro.Certificado, "2.00", out msgRetorno, out msgWSRetorno, out codRetorno, out msgResultado, BuscaNota.ChaveNFe, BuscaNota.ProtocoloDeAutorizacao, util.Justificativa, out nroProtocoloCan, out dhProtcoloCan, "", "", "", "a907ec9e495ff56bb33991edf9ffdb7a29410493a560cd66af94dd685715840d5367736393bf27a2a4d49cbdefe93035b0c88e50e61ace4847fa57b742366b03");
                        if (codRetorno == 101)
                        {
                            string Caminho = @"C:\Envio\";
                            nomeNota = String.Format("{0}NFe{1}-nfe.xml", Caminho, BuscaNota.ChaveNFe);
                            Validacoes.Informacao("NF-e Cancelada com sucesso!");
                            using (StreamWriter Arquivo = new StreamWriter(nomeNota))
                            {
                                Arquivo.Write(ProcCancelNFE);
                                Arquivo.Close();
                            }
                            BuscaNota.ProtocoloDeCancelamento = nroProtocoloCan;
                            Entidades.ObjectStateManager.ChangeObjectState(BuscaNota, EntityState.Modified);
                            Entidades.SaveChanges();
                        }
                        else
                        {
                            MessageBox.Show("Erro ao cancelar a NF-e" + codRetorno.ToString(), "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                    }

                }

                objNFeUtil = null;
                GC.Collect();
            }
            catch
            {
                MessageBox.Show("Erro ao cancelar a NF-e");
            }
        }

        #region Enviar E-mail
        private void btnEnviarPorEmail_Click(object sender, EventArgs e)
        {
            EnviaEmail();
        }
        #endregion

        private void EnviaEmail()
        {
            try
            {   
                string Caminho = @"C:\Envio\";
                Util NFE = new Util();
                int Codigo = Convert.ToInt32(CodigoPedido);
                var Parametro = Entidades.Parametros.FirstOrDefault();
                var BuscaNota = Entidades.PedidoCabeca.FirstOrDefault(ped => ped.CodigoPedido == Codigo);
                if (BuscaNota.Clientes.Email == "")
                {
                    throw new Exception("Cliente não possui e-mail cadastrado, verifique!");
                }
                string Resultado;

                if (File.Exists(String.Format("{0}{1}.pdf", Caminho, BuscaNota.ChaveNFe)) == false)
                {
                    int GerarPDF = NFE.geraPdfDANFE(BuscaNota.XML_NFe, "", "S", "N", "N", "", "Z", "[NFeId.PDF]", out Resultado);
                    File.Move(BuscaNota.ChaveNFe + ".pdf", String.Format("{0}{1}.pdf", Caminho, BuscaNota.ChaveNFe));
                }
                if (File.Exists(String.Format("{0}{1}.xml", Caminho, BuscaNota.ChaveNFe)) == false)
                {
                    nomeNota = String.Format("{0}{1}.xml", Caminho, BuscaNota.ChaveNFe);
                    using (StreamWriter Arquivo = new StreamWriter(nomeNota))
                    {
                        Arquivo.Write(BuscaNota.XML_NFe);
                        Arquivo.Close();
                    }
                }
                string Mensagem = String.Format("<font face='Verdana, Geneva, sans-serif' size='2'>Prezado Cliente,<br />Obrigado por comprar na Inplast Ind. e Com. de Emb Plásticas Ltda Estamos encaminhando esse e-mail contendo em anexo, o arquivo eletrônico da sua Nota Fiscal de Compra e a DANFE em PDF do documento de numero <strong>{0}</strong>; de acordo como 'Manual de Integração do Contribuinte' da Nota Fiscal Eletrônica.<br /> <br /> <br /> <br /> Atenciosamente,<br />A Administração<br />PS. Caso tenha alguma dúvida favor entrar em contato conosco pelo fone: (65) 3684-3232 ou E-mail: inplast-mt@uol.com.br<br /><strong>Favor não responder!</strong>. Esse e-mail foi enviado automáticamente pelo nosso servidor após registro da autorização de uso da NF-e para a vossa Empresa.</font>", BuscaNota.NumNFe);

                int Nota = NFE.EnvEmail("nao.responda.nfe.inplast@gmail.com", "NF-e Inplast Ind. e Com. de Embalagens", BuscaNota.Clientes.Email, "inplas-mt@uol.com.br", "NF-e Inplast", Mensagem, String.Format("{0}{1}.pdf;{0}{1}.xml", Caminho, BuscaNota.ChaveNFe), "smtp.gmail.com", "587", "1", "nao.responda.nfe.inplast@gmail.com", "proxy8500", "1", "1", out Resultado);
                if (Nota == 7100)
                {
                    Validacoes.Informacao("Arquivos enviados com sucesso!");
                    Close();
                }
                else
                {
                    throw new Exception("Erro ao enviar os arquivos");
                }

                NFE = null;
                GC.Collect();
            }
            catch (Exception ex)
            {
                Validacoes.Erro("Erro ao enviar e-mail, o erro foi: " + ex.Message.ToString());
            }
        }

        private void btnObs_Click(object sender, EventArgs e)
        {
            using (frmNFEObservacoes Obs = new frmNFEObservacoes())
            {
                Obs.ShowDialog();
            }
        }
    }


}
